home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / network / admin / xinetd.2 / xinetd / xinetd.2.1.7-linux.4 / libs / src / misc / env.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-09-10  |  4.8 KB  |  291 lines
  1. /*
  2.  * (c) Copyright 1992 by Panagiotis Tsirigotis
  3.  * All rights reserved.  The file named COPYRIGHT specifies the terms 
  4.  * and conditions for redistribution.
  5.  */
  6.  
  7. static char RCSid[] = "$Id: env.c,v 1.5 1995/09/10 18:32:56 chuck Exp $" ;
  8.  
  9. #include <memory.h>
  10. #include <string.h>
  11. #include <sys/param.h>
  12.  
  13. #include "misc.h"
  14. #include "env.h"
  15.  
  16. typedef struct __env env_s ;
  17.  
  18. #define PRIVATE                    static
  19. #define INITIAL_VARS                20
  20. #define INCREASE                    10
  21.  
  22. #ifndef NULL
  23. #define NULL                        0
  24. #endif
  25.  
  26. #if defined(linux) || defined(BSD)
  27. PRIVATE char **lookup( env_h env , char *var , register int len ) ;
  28. #endif
  29.  
  30. char *malloc() ;
  31. char *realloc() ;
  32.  
  33. int env_errno ;
  34.  
  35.  
  36.  
  37. PRIVATE env_s *alloc_env( max_vars )
  38.     unsigned max_vars ;
  39. {
  40.     env_s *ep ;
  41.     unsigned size ;
  42.     char **pointers ;
  43.  
  44.     ep = (env_s *) malloc( sizeof( env_s ) ) ;
  45.     if ( ep == ENV_NULL )
  46.     {
  47.         env_errno = ENV_ENOMEM ;
  48.         return( ENV_NULL ) ;
  49.     }
  50.  
  51.     size = ( max_vars + 1 ) * sizeof( char * ) ;
  52.     pointers = (char **) malloc( size ) ;
  53.     if ( pointers == NULL )
  54.     {
  55.         free( (char *)ep ) ;
  56.         env_errno = ENV_ENOMEM ;
  57.         return( ENV_NULL ) ;
  58.     }
  59.     (void) memset( (char *)pointers, 0, (int) size ) ;
  60.  
  61.     ep->vars = pointers ;
  62.     ep->max_vars = max_vars ;
  63.     ep->n_vars = 0 ;
  64.     return( ep ) ;
  65. }
  66.  
  67.  
  68. env_h env_create( init_env )
  69.     env_h init_env ;
  70. {
  71.     unsigned u ;
  72.     env_s *ep ;
  73.     unsigned max_vars ;
  74.  
  75.     if ( init_env == ENV_NULL )
  76.         max_vars = INITIAL_VARS ;
  77.     else
  78.         max_vars = init_env->n_vars + 5 ;
  79.     
  80.     ep = alloc_env( max_vars ) ;
  81.     if ( ep == NULL )
  82.     {
  83.         env_errno = ENV_ENOMEM ;
  84.         return( ENV_NULL ) ;
  85.     }
  86.  
  87.     if ( init_env == ENV_NULL )
  88.         return( ep ) ;
  89.  
  90.     for ( u = 0, ep->n_vars = 0 ; u < init_env->n_vars ; u++, ep->n_vars++ )
  91.     {
  92.         ep->vars[ ep->n_vars ] = make_string( 1, init_env->vars[ u ] ) ;
  93.         if ( ep->vars[ ep->n_vars ] == NULL )
  94.         {
  95.             env_destroy( ep ) ;
  96.             env_errno = ENV_ENOMEM ;
  97.             return( ENV_NULL ) ;
  98.         }
  99.     }
  100.     return( ep ) ;
  101. }
  102.  
  103.  
  104. void env_destroy( env )
  105.     env_h env ;
  106. {
  107.     unsigned u ;
  108.  
  109.     for ( u = 0 ; u < env->n_vars ; u++ )
  110.         free( env->vars[ u ] ) ;
  111.     free( (char *)env->vars ) ;
  112.     free( (char *)env ) ;
  113. }
  114.  
  115.  
  116. env_h env_make( env_strings )
  117.     char **env_strings ;
  118. {
  119.     env_s *ep ;
  120.     char **pp ;
  121.  
  122.     for ( pp = env_strings ; *pp ; pp++ ) ;
  123.  
  124.     ep = alloc_env( (unsigned) (pp-env_strings) ) ;
  125.     if ( ep == NULL )
  126.     {
  127.         env_errno = ENV_ENOMEM ;
  128.         return( ENV_NULL ) ;
  129.     }
  130.  
  131.     for ( pp = env_strings ; *pp ; pp++ )
  132.     {
  133.         char *p = make_string( 1, *pp ) ;
  134.  
  135.         if ( p == NULL )
  136.         {
  137.             env_destroy( ep ) ;
  138.             env_errno = ENV_ENOMEM ;
  139.             return( ENV_NULL ) ;
  140.         }
  141.         ep->vars[ ep->n_vars++ ] = p ;
  142.     }
  143.     return( ep ) ;
  144. }
  145.  
  146.  
  147. char *env_lookup( env, var )
  148.     env_h env ;
  149.     char *var ;
  150. {
  151.     char **lookup() ;
  152.     char **pp = lookup( env, var, strlen( var ) ) ;
  153.  
  154.     return( ( pp == NULL ) ? NULL : *pp ) ;
  155. }
  156.  
  157.  
  158. PRIVATE char **lookup( env, var, len )
  159.     env_h env ;
  160.     char *var ;
  161.     register int len ;
  162. {
  163.     register char **pp ;
  164.  
  165.     for ( pp = env->vars ; *pp ; pp++ )
  166.         if ( strncmp( *pp, var, len ) == 0 && (*pp)[ len ] == '=' )
  167.             return( pp ) ;
  168.     return( NULL ) ;
  169. }
  170.  
  171.  
  172. PRIVATE int grow( ep )
  173.     env_s *ep ;
  174. {
  175.     char **new_vars ;
  176.     unsigned new_max_vars ;
  177.     unsigned new_size ;
  178.  
  179.     new_max_vars = ep->max_vars + INCREASE ;
  180.     new_size = ( new_max_vars+1 ) * sizeof( char * ) ;
  181.     new_vars = (char **) realloc( (char *)ep->vars, new_size ) ;
  182.     if ( new_vars == NULL )
  183.         return( ENV_ERR ) ;
  184.     
  185.     ep->vars = new_vars ;
  186.     ep->max_vars = new_max_vars ;
  187.     return( ENV_OK ) ;
  188. }
  189.  
  190.  
  191. /*
  192.  * Add the variable string to the given environment.
  193.  */
  194. PRIVATE int addstring( ep, var_string, len )
  195.     env_s *ep ;
  196.     char *var_string ;
  197.     int len ;
  198. {
  199.     char **pp ;
  200.     char *p ;
  201.  
  202.     p = make_string( 1, var_string ) ;
  203.     if ( p == NULL )
  204.         return( ENV_ERR ) ;
  205.         
  206.     pp = lookup( ep, var_string, len ) ;
  207.     if ( pp == NULL )
  208.     {
  209.         if ( ep->n_vars >= ep->max_vars && grow( ep ) == ENV_ERR )
  210.         {
  211.             free( p ) ;
  212.             env_errno = ENV_ENOMEM ;
  213.             return( ENV_ERR ) ;
  214.         }
  215.         ep->vars[ ep->n_vars++ ] = p ;
  216.     }
  217.     else
  218.     {
  219.         free( *pp ) ;
  220.         *pp = p ;
  221.     }
  222.     return( ENV_OK ) ;
  223. }
  224.  
  225.  
  226. int env_addvar( env, from_env, var_name )
  227.     env_h env ;
  228.     env_h from_env ;
  229.     char *var_name ;
  230. {
  231.     char *var_string = env_lookup( from_env, var_name ) ;
  232.  
  233.     if ( var_string == NULL )
  234.     {
  235.         env_errno = ENV_EBADVAR ;
  236.         return( ENV_ERR ) ;
  237.     }
  238.  
  239.     return( addstring( env, var_string, strlen( var_name ) ) ) ;
  240. }
  241.  
  242.  
  243. int env_addstr( env, var_string )
  244.     env_h env ;
  245.     char *var_string ;
  246. {
  247.     char *p = strchr( var_string, '=' ) ;
  248.  
  249.     if ( p == NULL )
  250.     {
  251.         env_errno = ENV_EBADSTRING ;
  252.         return( ENV_ERR ) ;
  253.     }
  254.     
  255.     return( addstring( env, var_string, p-var_string ) ) ;
  256. }
  257.  
  258.  
  259. int env_remvar( env, var )
  260.     env_h env ;
  261.     char *var ;
  262. {
  263.     char **pp = lookup( env, var, strlen( var ) ) ;
  264.  
  265.     if ( pp == NULL )
  266.     {
  267.         env_errno = ENV_EBADVAR ;
  268.         return( ENV_ERR ) ;
  269.     }
  270.     
  271.     free( *pp ) ;
  272.     *pp = env->vars[ --env->n_vars ] ;
  273.     return( ENV_OK ) ;
  274. }
  275.  
  276.  
  277. #ifdef notdef
  278. PRIVATE int comparator( p1, p2 )
  279.     char **p1, **p2 ;
  280. {
  281.     return( strcmp( *p1, *p2 ) ) ;
  282. }
  283.  
  284.  
  285. void env_sort( env )
  286.     env_h env ;
  287. {
  288.     qsort( (char *)env->vars, env->n_vars, sizeof( char * ), comparator ) ;
  289. }
  290. #endif
  291.